home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Development Tools & Languages / • Other Platforms / PCCTS 1.31 / antlr / antlr.c next >
Encoding:
C/C++ Source or Header  |  1995-03-10  |  48.6 KB  |  2,385 lines  |  [TEXT/MPS ]
  1. /*
  2.  * A n t l r  T r a n s l a t i o n  H e a d e r
  3.  *
  4.  * Terence Parr, Will Cohen, and Hank Dietz: 1989-1994
  5.  * Purdue University Electrical Engineering
  6.  * With AHPCRC, University of Minnesota
  7.  * ANTLR Version 1.31
  8.  */
  9. #include <stdio.h>
  10. #define ANTLR_VERSION    131
  11.  
  12. #ifdef __cplusplus
  13. #ifndef __STDC__
  14. #define __STDC__
  15. #endif
  16. #endif
  17. #include "set.h"
  18. #include <ctype.h>
  19. #include "syn.h"
  20. #include "hash.h"
  21. #include "generic.h"
  22. #define zzcr_attr(attr,tok,t)
  23. #define zzSET_SIZE 20
  24. #include "antlr.h"
  25. #include "tokens.h"
  26. #include "dlgdef.h"
  27. #include "mode.h"
  28. ANTLR_INFO
  29.  
  30. #ifdef __STDC__
  31. static void chkToken(char *, char *, char *, int);
  32. #else
  33. static void chkToken();
  34. #endif
  35.  
  36. static int class_nest_level = 0;
  37. extern int inAlt;
  38. extern set attribsRefdFromAction;
  39. extern int UsedOldStyleAttrib;
  40. extern int UsedNewStyleLabel;
  41.  
  42. void
  43. #ifdef __STDC__
  44. grammar(void)
  45. #else
  46. grammar()
  47. #endif
  48. {
  49.     zzRULE;
  50.     zzBLOCK(zztasp1);
  51.     zzMake0;
  52.     {
  53.     Graph g;  
  54.     {
  55.         zzBLOCK(zztasp2);
  56.         zzMake0;
  57.         {
  58.         while ( 1 ) {
  59.             if ( !((setwd1[LA(1)]&0x1))) break;
  60.             if ( (LA(1)==86) ) {
  61.                 zzmatch(86); zzCONSUME;
  62.                 zzmatch(Action);
  63.                 
  64.                 if ( HdrAction==NULL ) {
  65.                     HdrAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  66.                     require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
  67.                     strcpy(HdrAction, LATEXT(1));
  68.                 }
  69.                 else warn("additional #header statement ignored");
  70.  zzCONSUME;
  71.  
  72.             }
  73.             else {
  74.                 if ( (LA(1)==87) ) {
  75.                     zzmatch(87); zzCONSUME;
  76.                     zzmatch(QuotedTerm);
  77.                     
  78.                     if ( GenCC ) {
  79.                         warn("#parser meta-op incompatible with -CC; ignored");
  80.                     }
  81.                     else {
  82.                         if ( strcmp(ParserName,"zzparser")==0 ) {
  83.                             ParserName=StripQuotes(mystrdup(LATEXT(1)));
  84.                             if ( RulePrefix[0]!='\0' )
  85.                             {
  86.                                 warn("#parser meta-op incompatible with '-gp prefix'; '-gp' ignored");
  87.                                 RulePrefix[0]='\0';
  88.                             }
  89.                         }
  90.                         else warn("additional #parser statement ignored");
  91.                     }
  92.  zzCONSUME;
  93.  
  94.                 }
  95.                 else {
  96.                     if ( (LA(1)==88) ) {
  97.                         zzmatch(88); zzCONSUME;
  98.                         zzmatch(QuotedTerm);
  99.                         {
  100.                             char *fname;
  101.                             zzantlr_state st; FILE *f; struct zzdlg_state dst;
  102.                             UserTokenDefsFile = mystrdup(LATEXT(1));
  103.                             zzsave_antlr_state(&st);
  104.                             zzsave_dlg_state(&dst);
  105.                             fname = mystrdup(LATEXT(1));
  106.                             f = fopen(StripQuotes(fname), "r");
  107.                             if ( f==NULL ) {warn(eMsg1("cannot open token defs file '%s'", fname+1));}
  108.                             else {
  109.                                 ANTLRm(enum_file(fname+1), f, PARSE_ENUM_FILE);
  110.                                 UserDefdTokens = 1;
  111.                             }
  112.                             zzrestore_antlr_state(&st);
  113.                             zzrestore_dlg_state(&dst);
  114.                         }  
  115.  zzCONSUME;
  116.  
  117.                     }
  118.                 }
  119.             }
  120.             zzLOOP(zztasp2);
  121.         }
  122.         zzEXIT(zztasp2);
  123.         }
  124.     }
  125.     {
  126.         zzBLOCK(zztasp2);
  127.         zzMake0;
  128.         {
  129.         while ( 1 ) {
  130.             if ( !((setwd1[LA(1)]&0x2))) break;
  131.             if ( (LA(1)==Action) ) {
  132.                 zzmatch(Action);
  133.                 {
  134.                     UserAction *ua = newUserAction(LATEXT(1));
  135.                     ua->file = action_file; ua->line = action_line;
  136.                     if ( class_nest_level>0 ) list_add(&class_actions, ua);
  137.                     else list_add(&BeforeActions, ua);
  138.                 }  
  139.  zzCONSUME;
  140.  
  141.             }
  142.             else {
  143.                 if ( (LA(1)==99) ) {
  144.                     laction();
  145.                 }
  146.                 else {
  147.                     if ( (LA(1)==100) ) {
  148.                         aLexclass();
  149.                     }
  150.                     else {
  151.                         if ( (LA(1)==103) ) {
  152.                             token();
  153.                         }
  154.                         else {
  155.                             if ( (LA(1)==101) ) {
  156.                                 error();
  157.                             }
  158.                             else {
  159.                                 if ( (LA(1)==102) ) {
  160.                                     tclass();
  161.                                 }
  162.                                 else {
  163.                                     if ( (LA(1)==119) ) {
  164.                                         default_exception_handler();
  165.                                     }
  166.                                     else {
  167.                                         if ( (LA(1)==90) ) {
  168.                                             class_def();
  169.                                         }
  170.                                         else {
  171.                                             if ( (LA(1)==89) ) {
  172.                                                 zzmatch(89);
  173.                                                 
  174.                                                 if ( class_nest_level==0 )
  175.                                                 warn("missing class definition for trailing '}'");
  176.                                                 class_nest_level--;
  177.  zzCONSUME;
  178.  
  179.                                             }
  180.                                         }
  181.                                     }
  182.                                 }
  183.                             }
  184.                         }
  185.                     }
  186.                 }
  187.             }
  188.             zzLOOP(zztasp2);
  189.         }
  190.         zzEXIT(zztasp2);
  191.         }
  192.     }
  193.     rule();
  194.     g=zzaArg(zztasp1,3); SynDiag = (Junction *) zzaArg(zztasp1,3 ).left;  
  195.     {
  196.         zzBLOCK(zztasp2);
  197.         zzMake0;
  198.         {
  199.         while ( 1 ) {
  200.             if ( !((setwd1[LA(1)]&0x4))) break;
  201.             if ( (LA(1)==NonTerminal) ) {
  202.                 rule();
  203.                 if ( zzaArg(zztasp2,1 ).left!=NULL ) {g.right = NULL; g = Or(g, zzaArg(zztasp2,1));}  
  204.             }
  205.             else {
  206.                 if ( (LA(1)==100) ) {
  207.                     aLexclass();
  208.                 }
  209.                 else {
  210.                     if ( (LA(1)==103) ) {
  211.                         token();
  212.                     }
  213.                     else {
  214.                         if ( (LA(1)==101) ) {
  215.                             error();
  216.                         }
  217.                         else {
  218.                             if ( (LA(1)==102) ) {
  219.                                 tclass();
  220.                             }
  221.                             else {
  222.                                 if ( (LA(1)==90) ) {
  223.                                     class_def();
  224.                                 }
  225.                                 else {
  226.                                     if ( (LA(1)==89) ) {
  227.                                         zzmatch(89);
  228.                                         
  229.                                         if ( class_nest_level==0 )
  230.                                         warn("missing class definition for trailing '}'");
  231.                                         class_nest_level--;
  232.  zzCONSUME;
  233.  
  234.                                     }
  235.                                 }
  236.                             }
  237.                         }
  238.                     }
  239.                 }
  240.             }
  241.             zzLOOP(zztasp2);
  242.         }
  243.         zzEXIT(zztasp2);
  244.         }
  245.     }
  246.     {
  247.         zzBLOCK(zztasp2);
  248.         zzMake0;
  249.         {
  250.         while ( 1 ) {
  251.             if ( !((setwd1[LA(1)]&0x8))) break;
  252.             if ( (LA(1)==Action) ) {
  253.                 zzmatch(Action);
  254.                 {
  255.                     UserAction *ua = newUserAction(LATEXT(1));
  256.                     ua->file = action_file; ua->line = action_line;
  257.                     if ( class_nest_level>0 ) list_add(&class_actions, ua);
  258.                     else list_add(&AfterActions, ua);
  259.                 }  
  260.  zzCONSUME;
  261.  
  262.             }
  263.             else {
  264.                 if ( (LA(1)==99) ) {
  265.                     laction();
  266.                 }
  267.                 else {
  268.                     if ( (LA(1)==101) ) {
  269.                         error();
  270.                     }
  271.                     else {
  272.                         if ( (LA(1)==102) ) {
  273.                             tclass();
  274.                         }
  275.                         else {
  276.                             if ( (LA(1)==90) ) {
  277.                                 class_def();
  278.                             }
  279.                             else {
  280.                                 if ( (LA(1)==89) ) {
  281.                                     zzmatch(89);
  282.                                     
  283.                                     if ( class_nest_level==0 )
  284.                                     warn("missing class definition for trailing '}'");
  285.                                     class_nest_level--;
  286.  zzCONSUME;
  287.  
  288.                                 }
  289.                             }
  290.                         }
  291.                     }
  292.                 }
  293.             }
  294.             zzLOOP(zztasp2);
  295.         }
  296.         zzEXIT(zztasp2);
  297.         }
  298.     }
  299.     zzmatch(Eof); zzCONSUME;
  300.     zzEXIT(zztasp1);
  301.     return;
  302. fail:
  303.     zzEXIT(zztasp1);
  304.     CannotContinue=TRUE;  
  305.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  306.     zzresynch(setwd1, 0x10);
  307.     }
  308. }
  309.  
  310. void
  311. #ifdef __STDC__
  312. class_def(void)
  313. #else
  314. class_def()
  315. #endif
  316. {
  317.     zzRULE;
  318.     zzBLOCK(zztasp1);
  319.     zzMake0;
  320.     {
  321.     int go=1; char name[MaxRuleName+1];  
  322.     zzmatch(90); zzCONSUME;
  323.     {
  324.         zzBLOCK(zztasp2);
  325.         zzMake0;
  326.         {
  327.         if ( (LA(1)==NonTerminal) ) {
  328.             zzmatch(NonTerminal);
  329.             if(go) strncpy(name,LATEXT(1),MaxRuleName);  
  330.  zzCONSUME;
  331.  
  332.         }
  333.         else {
  334.             if ( (LA(1)==TokenTerm) ) {
  335.                 zzmatch(TokenTerm);
  336.                 if(go) strncpy(name,LATEXT(1),MaxRuleName);  
  337.  zzCONSUME;
  338.  
  339.             }
  340.             else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  341.         }
  342.         zzEXIT(zztasp2);
  343.         }
  344.     }
  345.     
  346.     if ( CurrentClassName[0]!='\0' && strcmp(CurrentClassName,name)!=0
  347.     && GenCC ) {
  348.         err("only one grammar class allowed in this release");
  349.         go = 0;
  350.     }
  351.     else strcpy(CurrentClassName, name);
  352.     if ( !GenCC ) { err("class meta-op used without C++ option"); }  
  353.     zzmatch(93);
  354.     
  355.     no_classes_found = 0;
  356.     if ( class_nest_level>=1 ) {warn("cannot have nested classes");}
  357.     else class_nest_level++;
  358.  zzCONSUME;
  359.  
  360.     zzEXIT(zztasp1);
  361.     return;
  362. fail:
  363.     zzEXIT(zztasp1);
  364.     CannotContinue=TRUE;  
  365.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  366.     zzresynch(setwd1, 0x20);
  367.     }
  368. }
  369.  
  370. void
  371. #ifdef __STDC__
  372. rule(void)
  373. #else
  374. rule()
  375. #endif
  376. {
  377.     zzRULE;
  378.     zzBLOCK(zztasp1);
  379.     zzMake0;
  380.     {
  381.     
  382.     ListNode *ex_groups = NULL;
  383.     ExceptionGroup *eg;
  384.     RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
  385.     set toksrefd, rulesrefd;
  386.     char *pdecl=NULL, *ret=NULL, *a; CurRetDef = CurParmDef = NULL;
  387.     CurExGroups = NULL;
  388.     CurElementLabels = NULL;
  389.     /* We want a new element label hash table for each rule */
  390.     if ( Elabel!=NULL ) killHashTable(Elabel);
  391.     Elabel = newHashTable();
  392.     attribsRefdFromAction = empty;
  393.     zzmatch(NonTerminal);
  394.     q=NULL;
  395.     if ( hash_get(Rname, LATEXT(1))!=NULL ) {
  396.         err(eMsg1("duplicate rule definition: '%s'",LATEXT(1)));
  397.         CannotContinue=TRUE;
  398.     }
  399.     else
  400.     {
  401.         q = (RuleEntry *)hash_add(Rname,
  402.         LATEXT(1),
  403.         (Entry *)newRuleEntry(LATEXT(1)));
  404.         CurRule = q->str;
  405.     }
  406.     CurRuleNode = q;
  407.     f = CurFile; l = zzline;
  408.     NumRules++;
  409.  zzCONSUME;
  410.  
  411.     {
  412.         zzBLOCK(zztasp2);
  413.         zzMake0;
  414.         {
  415.         if ( (LA(1)==94) ) {
  416.             zzmatch(94);
  417.             if ( q!=NULL ) q->noAST = TRUE;  
  418.  zzCONSUME;
  419.  
  420.         }
  421.         zzEXIT(zztasp2);
  422.         }
  423.     }
  424.     {
  425.         zzBLOCK(zztasp2);
  426.         zzMake0;
  427.         {
  428.         ;  
  429.         if ( (setwd1[LA(1)]&0x40) ) {
  430.             {
  431.                 zzBLOCK(zztasp3);
  432.                 zzMake0;
  433.                 {
  434.                 if ( (LA(1)==95) ) {
  435.                     zzmatch(95); zzCONSUME;
  436.                 }
  437.                 zzEXIT(zztasp3);
  438.                 }
  439.             }
  440.             zzmatch(PassAction);
  441.             pdecl = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  442.             require(pdecl!=NULL, "rule rule: cannot allocate param decl");
  443.             strcpy(pdecl, LATEXT(1));
  444.             CurParmDef = pdecl;
  445.  zzCONSUME;
  446.  
  447.         }
  448.         zzEXIT(zztasp2);
  449.         }
  450.     }
  451.     {
  452.         zzBLOCK(zztasp2);
  453.         zzMake0;
  454.         {
  455.         if ( (LA(1)==96) ) {
  456.             zzmatch(96); zzCONSUME;
  457.             zzmatch(PassAction);
  458.             ret = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  459.             require(ret!=NULL, "rule rule: cannot allocate ret type");
  460.             strcpy(ret, LATEXT(1));
  461.             CurRetDef = ret;
  462.  zzCONSUME;
  463.  
  464.         }
  465.         zzEXIT(zztasp2);
  466.         }
  467.     }
  468.     {
  469.         zzBLOCK(zztasp2);
  470.         zzMake0;
  471.         {
  472.         if ( (LA(1)==QuotedTerm) ) {
  473.             zzmatch(QuotedTerm);
  474.             if ( q!=NULL ) q->egroup=mystrdup(LATEXT(1));  
  475.  zzCONSUME;
  476.  
  477.         }
  478.         zzEXIT(zztasp2);
  479.         }
  480.     }
  481.     
  482.     if ( GenEClasseForRules && q!=NULL ) {
  483.         e = newECnode;
  484.         require(e!=NULL, "cannot allocate error class node");
  485.         if ( q->egroup == NULL ) {a = q->str; a[0] = (char)toupper(a[0]);}
  486.         else a = q->egroup;
  487.         if ( Tnum( a ) == 0 )
  488.         {
  489.             e->tok = addTname( a );
  490.             list_add(&eclasses, (char *)e);
  491.             if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  492.             /* refers to itself */
  493.             list_add(&(e->elist), mystrdup(q->str));
  494.         }
  495.         else {
  496.             warn(eMsg1("default errclass for '%s' would conflict with token/errclass/tokclass",a));
  497.             if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  498.             free((char *)e);
  499.         }
  500.     }
  501.     BlkLevel++;  
  502.     zzmatch(97);
  503.     inAlt=1;  
  504.  zzCONSUME;
  505.  
  506.     block( &toksrefd, &rulesrefd );
  507.     r = makeBlk(zzaArg(zztasp1,7),0);
  508.     CurRuleBlk = (Junction *)r.left;
  509.     CurRuleBlk->blockid = CurBlockID;
  510.     CurRuleBlk->jtype = RuleBlk;
  511.     if ( q!=NULL ) CurRuleBlk->rname = q->str;
  512.     CurRuleBlk->file = f;
  513.     CurRuleBlk->line = l;
  514.     CurRuleBlk->pdecl = pdecl;
  515.     CurRuleBlk->ret = ret;
  516.     CurRuleBlk->lock = makelocks();
  517.     CurRuleBlk->pred_lock = makelocks();
  518.     CurRuleBlk->tokrefs = toksrefd;
  519.     CurRuleBlk->rulerefs = rulesrefd;
  520.     p = newJunction();    /* add EndRule Node */
  521.     ((Junction *)r.right)->p1 = (Node *)p;
  522.     r.right = (Node *) p;
  523.     p->jtype = EndRule;
  524.     p->lock = makelocks();
  525.     p->pred_lock = makelocks();
  526.     CurRuleBlk->end = p;
  527.     if ( q!=NULL ) q->rulenum = NumRules;
  528.     zzaArg(zztasp1,7) = r;
  529.     --BlkLevel;  
  530.     zzmatch(98);
  531.     inAlt=0;  
  532.  zzCONSUME;
  533.  
  534.     {
  535.         zzBLOCK(zztasp2);
  536.         zzMake0;
  537.         {
  538.         if ( (LA(1)==Action) ) {
  539.             zzmatch(Action);
  540.             a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  541.             require(a!=NULL, "rule rule: cannot allocate error action");
  542.             strcpy(a, LATEXT(1));
  543.             CurRuleBlk->erraction = a;
  544.  zzCONSUME;
  545.  
  546.         }
  547.         zzEXIT(zztasp2);
  548.         }
  549.     }
  550.     {
  551.         zzBLOCK(zztasp2);
  552.         zzMake0;
  553.         {
  554.         while ( (LA(1)==119) ) {
  555.              eg  = exception_group();
  556.  
  557.             if ( eg!=NULL ) {
  558.                 list_add(&CurExGroups, (void *)eg);
  559.                 if ( eg->label=='\0' ) q->has_rule_exception = 1;
  560.             }
  561.             zzLOOP(zztasp2);
  562.         }
  563.         zzEXIT(zztasp2);
  564.         }
  565.     }
  566.     if ( q==NULL ) zzaArg(zztasp1,0 ).left = NULL; else zzaArg(zztasp1,0) = zzaArg(zztasp1,7);  
  567.     CurRuleNode = NULL;  
  568.     CurRuleBlk->exceptions = CurExGroups;  
  569.     CurRuleBlk->el_labels = CurElementLabels;  
  570.     zzEXIT(zztasp1);
  571.     return;
  572. fail:
  573.     zzEXIT(zztasp1);
  574.     CannotContinue=TRUE;  
  575.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  576.     zzresynch(setwd1, 0x80);
  577.     }
  578. }
  579.  
  580. void
  581. #ifdef __STDC__
  582. laction(void)
  583. #else
  584. laction()
  585. #endif
  586. {
  587.     zzRULE;
  588.     zzBLOCK(zztasp1);
  589.     zzMake0;
  590.     {
  591.     char *a;  
  592.     zzmatch(99); zzCONSUME;
  593.     zzmatch(Action);
  594.     
  595.     a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  596.     require(a!=NULL, "rule laction: cannot allocate action");
  597.     strcpy(a, LATEXT(1));
  598.     list_add(&LexActions, a);
  599.  zzCONSUME;
  600.  
  601.     zzEXIT(zztasp1);
  602.     return;
  603. fail:
  604.     zzEXIT(zztasp1);
  605.     CannotContinue=TRUE;  
  606.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  607.     zzresynch(setwd2, 0x1);
  608.     }
  609. }
  610.  
  611. void
  612. #ifdef __STDC__
  613. aLexclass(void)
  614. #else
  615. aLexclass()
  616. #endif
  617. {
  618.     zzRULE;
  619.     zzBLOCK(zztasp1);
  620.     zzMake0;
  621.     {
  622.     zzmatch(100); zzCONSUME;
  623.     zzmatch(TokenTerm);
  624.     lexclass(mystrdup(LATEXT(1)));  
  625.  zzCONSUME;
  626.  
  627.     zzEXIT(zztasp1);
  628.     return;
  629. fail:
  630.     zzEXIT(zztasp1);
  631.     CannotContinue=TRUE;  
  632.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  633.     zzresynch(setwd2, 0x2);
  634.     }
  635. }
  636.  
  637. void
  638. #ifdef __STDC__
  639. error(void)
  640. #else
  641. error()
  642. #endif
  643. {
  644.     zzRULE;
  645.     zzBLOCK(zztasp1);
  646.     zzMake0;
  647.     {
  648.     char *t=NULL; ECnode *e; int go=1; TermEntry *p;  
  649.     zzmatch(101); zzCONSUME;
  650.     {
  651.         zzBLOCK(zztasp2);
  652.         zzMake0;
  653.         {
  654.         ;  
  655.         if ( (LA(1)==TokenTerm) ) {
  656.             zzmatch(TokenTerm);
  657.             t=mystrdup(LATEXT(1));  
  658.  zzCONSUME;
  659.  
  660.         }
  661.         else {
  662.             if ( (LA(1)==QuotedTerm) ) {
  663.                 zzmatch(QuotedTerm);
  664.                 t=mystrdup(LATEXT(1));  
  665.  zzCONSUME;
  666.  
  667.             }
  668.             else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  669.         }
  670.         zzEXIT(zztasp2);
  671.         }
  672.     }
  673.     e = newECnode;
  674.     require(e!=NULL, "cannot allocate error class node");
  675.     e->lexclass = CurrentLexClass;
  676.     if ( Tnum( (t=StripQuotes(t)) ) == 0 )
  677.     {
  678.         if ( hash_get(Texpr, t) != NULL )
  679.         warn(eMsg1("errclass name conflicts with regular expression  '%s'",t));
  680.         e->tok = addTname( t );
  681.         set_orel(e->tok, &imag_tokens);
  682.         require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  683.         "hash table mechanism is broken");
  684.         p->classname = 1;    /* entry is errclass name, not token */
  685.         list_add(&eclasses, (char *)e);
  686.     }
  687.     else
  688.     {
  689.     warn(eMsg1("redefinition of errclass or conflict w/token or tokclass '%s'; ignored",t));
  690.     free( (char *)e );
  691.     go=0;
  692. }
  693.     zzmatch(93); zzCONSUME;
  694.     {
  695.         zzBLOCK(zztasp2);
  696.         zzMake0;
  697.         {
  698.         if ( (LA(1)==NonTerminal) ) {
  699.             zzmatch(NonTerminal);
  700.             if ( go ) t=mystrdup(LATEXT(1));  
  701.  zzCONSUME;
  702.  
  703.         }
  704.         else {
  705.             if ( (LA(1)==TokenTerm) ) {
  706.                 zzmatch(TokenTerm);
  707.                 if ( go ) t=mystrdup(LATEXT(1));  
  708.  zzCONSUME;
  709.  
  710.             }
  711.             else {
  712.                 if ( (LA(1)==QuotedTerm) ) {
  713.                     zzmatch(QuotedTerm);
  714.                     if ( go ) t=mystrdup(LATEXT(1));  
  715.  zzCONSUME;
  716.  
  717.                 }
  718.                 else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  719.             }
  720.         }
  721.         zzEXIT(zztasp2);
  722.         }
  723.     }
  724.     if ( go ) list_add(&(e->elist), t);  
  725.     {
  726.         zzBLOCK(zztasp2);
  727.         zzMake0;
  728.         {
  729.         while ( (setwd2[LA(1)]&0x4) ) {
  730.             {
  731.                 zzBLOCK(zztasp3);
  732.                 zzMake0;
  733.                 {
  734.                 if ( (LA(1)==NonTerminal) ) {
  735.                     zzmatch(NonTerminal);
  736.                     if ( go ) t=mystrdup(LATEXT(1));  
  737.  zzCONSUME;
  738.  
  739.                 }
  740.                 else {
  741.                     if ( (LA(1)==TokenTerm) ) {
  742.                         zzmatch(TokenTerm);
  743.                         if ( go ) t=mystrdup(LATEXT(1));  
  744.  zzCONSUME;
  745.  
  746.                     }
  747.                     else {
  748.                         if ( (LA(1)==QuotedTerm) ) {
  749.                             zzmatch(QuotedTerm);
  750.                             if ( go ) t=mystrdup(LATEXT(1));  
  751.  zzCONSUME;
  752.  
  753.                         }
  754.                         else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  755.                     }
  756.                 }
  757.                 zzEXIT(zztasp3);
  758.                 }
  759.             }
  760.             if ( go ) list_add(&(e->elist), t);  
  761.             zzLOOP(zztasp2);
  762.         }
  763.         zzEXIT(zztasp2);
  764.         }
  765.     }
  766.     zzmatch(89); zzCONSUME;
  767.     zzEXIT(zztasp1);
  768.     return;
  769. fail:
  770.     zzEXIT(zztasp1);
  771.     CannotContinue=TRUE;  
  772.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  773.     zzresynch(setwd2, 0x8);
  774.     }
  775. }
  776.  
  777. void
  778. #ifdef __STDC__
  779. tclass(void)
  780. #else
  781. tclass()
  782. #endif
  783. {
  784.     zzRULE;
  785.     zzBLOCK(zztasp1);
  786.     zzMake0;
  787.     {
  788.     char *t=NULL; TCnode *e; int go=1,tok; TermEntry *p, *term;  
  789.     zzmatch(102); zzCONSUME;
  790.     zzmatch(TokenTerm);
  791.     t=mystrdup(LATEXT(1));  
  792.  zzCONSUME;
  793.  
  794.     e = newTCnode;
  795.     require(e!=NULL, "cannot allocate token class node");
  796.     e->lexclass = CurrentLexClass;
  797.     if ( Tnum( t ) == 0 )
  798.     {
  799.         e->tok = addTname( t );
  800.         set_orel(e->tok, &imag_tokens);
  801.         set_orel(e->tok, &tokclasses);
  802.         require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  803.         "hash table mechanism is broken");
  804.         p->classname = 1;    /* entry is class name, not token */
  805.         p->tclass = e;        /* save ptr to this tclass def */
  806.         list_add(&tclasses, (char *)e);
  807.     }
  808.     else
  809.     {
  810.     warn(eMsg1("redefinition of tokclass or conflict w/token '%s'; ignored",t));
  811.     free( (char *)e );
  812.     go=0;
  813. }
  814.     zzmatch(93); zzCONSUME;
  815.     {
  816.         zzBLOCK(zztasp2);
  817.         zzMake0;
  818.         {
  819.         while ( (setwd2[LA(1)]&0x10) ) {
  820.             {
  821.                 zzBLOCK(zztasp3);
  822.                 zzMake0;
  823.                 {
  824.                 if ( (LA(1)==TokenTerm) ) {
  825.                     zzmatch(TokenTerm);
  826.                     if ( go ) {
  827.                         term = (TermEntry *) hash_get(Tname, LATEXT(1));
  828.                         if ( term==NULL && UserDefdTokens ) {
  829.                             err("implicit token definition not allowed with #tokdefs");
  830.                             go = 0;
  831.                         }
  832.                         else {t=mystrdup(LATEXT(1)); tok=addTname(LATEXT(1));}
  833.                     }  
  834.  zzCONSUME;
  835.  
  836.                 }
  837.                 else {
  838.                     if ( (LA(1)==QuotedTerm) ) {
  839.                         zzmatch(QuotedTerm);
  840.                         if ( go ) {
  841.                             term = (TermEntry *) hash_get(Texpr, LATEXT(1));
  842.                             if ( term==NULL && UserDefdTokens ) {
  843.                                 err("implicit token definition not allowed with #tokdefs");
  844.                                 go = 0;
  845.                             }
  846.                             else {t=mystrdup(LATEXT(1)); tok=addTexpr(LATEXT(1));}
  847.                         }  
  848.  zzCONSUME;
  849.  
  850.                     }
  851.                     else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  852.                 }
  853.                 zzEXIT(zztasp3);
  854.                 }
  855.             }
  856.             if ( go ) list_add(&(e->tlist), t);  
  857.             zzLOOP(zztasp2);
  858.         }
  859.         zzEXIT(zztasp2);
  860.         }
  861.     }
  862.     zzmatch(89); zzCONSUME;
  863.     zzEXIT(zztasp1);
  864.     return;
  865. fail:
  866.     zzEXIT(zztasp1);
  867.     CannotContinue=TRUE;  
  868.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  869.     zzresynch(setwd2, 0x20);
  870.     }
  871. }
  872.  
  873. void
  874. #ifdef __STDC__
  875. token(void)
  876. #else
  877. token()
  878. #endif
  879. {
  880.     zzRULE;
  881.     zzBLOCK(zztasp1);
  882.     zzMake0;
  883.     {
  884.     char *t=NULL, *e=NULL, *a=NULL; int tnum=0;  
  885.     zzmatch(103); zzCONSUME;
  886.     {
  887.         zzBLOCK(zztasp2);
  888.         zzMake0;
  889.         {
  890.         if ( (LA(1)==TokenTerm) ) {
  891.             zzmatch(TokenTerm);
  892.             t=mystrdup(LATEXT(1));  
  893.  zzCONSUME;
  894.  
  895.             {
  896.                 zzBLOCK(zztasp3);
  897.                 zzMake0;
  898.                 {
  899.                 if ( (LA(1)==104) ) {
  900.                     zzmatch(104); zzCONSUME;
  901.                     zzmatch(105);
  902.                     tnum = atoi(LATEXT(1));  
  903.  zzCONSUME;
  904.  
  905.                 }
  906.                 zzEXIT(zztasp3);
  907.                 }
  908.             }
  909.         }
  910.         zzEXIT(zztasp2);
  911.         }
  912.     }
  913.     {
  914.         zzBLOCK(zztasp2);
  915.         zzMake0;
  916.         {
  917.         if ( (LA(1)==QuotedTerm) ) {
  918.             zzmatch(QuotedTerm);
  919.             e=mystrdup(LATEXT(1));  
  920.  zzCONSUME;
  921.  
  922.         }
  923.         zzEXIT(zztasp2);
  924.         }
  925.     }
  926.     {
  927.         zzBLOCK(zztasp2);
  928.         zzMake0;
  929.         {
  930.         if ( (LA(1)==Action) ) {
  931.             zzmatch(Action);
  932.             
  933.             a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  934.             require(a!=NULL, "rule token: cannot allocate action");
  935.             strcpy(a, LATEXT(1));
  936.  zzCONSUME;
  937.  
  938.         }
  939.         zzEXIT(zztasp2);
  940.         }
  941.     }
  942.     chkToken(t, e, a, tnum);  
  943.     zzEXIT(zztasp1);
  944.     return;
  945. fail:
  946.     zzEXIT(zztasp1);
  947.     CannotContinue=TRUE;  
  948.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  949.     zzresynch(setwd2, 0x40);
  950.     }
  951. }
  952.  
  953. void
  954. #ifdef __STDC__
  955. block( set *toksrefd, set *rulesrefd )
  956. #else
  957. block(toksrefd,rulesrefd)
  958.  set *toksrefd;
  959. set *rulesrefd ;
  960. #endif
  961. {
  962.     zzRULE;
  963.     zzBLOCK(zztasp1);
  964.     zzMake0;
  965.     {
  966.     
  967.     Graph g, b;
  968.     set saveblah;
  969.     int saveinalt = inAlt;
  970.     ExceptionGroup *eg;
  971.     * toksrefd = empty;
  972.     * rulesrefd = empty;
  973.     set_clr(AST_nodes_refd_in_actions);
  974.     CurBlockID++;
  975.     CurAltNum = 1;
  976.     saveblah = attribsRefdFromAction;
  977.     attribsRefdFromAction = empty;
  978.     alt( toksrefd,rulesrefd );
  979.     b = g = zzaArg(zztasp1,1);  
  980.     
  981.     if ( ((Junction *)g.left)->p1->ntype == nAction )
  982.     {
  983.         if ( !((ActionNode *)(((Junction *)g.left)->p1))->is_predicate )
  984.         {
  985.             ((ActionNode *)(((Junction *)g.left)->p1))->init_action = TRUE;
  986.         }
  987.     }
  988.     ((Junction *)g.left)->blockid = CurBlockID;
  989.     {
  990.         zzBLOCK(zztasp2);
  991.         zzMake0;
  992.         {
  993.         while ( (LA(1)==119) ) {
  994.              eg  = exception_group();
  995.  
  996.             
  997.             if ( eg!=NULL ) {
  998.                 eg->altID = makeAltID(CurBlockID,CurAltNum);
  999.                 CurAltStart->exception_label = eg->altID;
  1000.                 list_add(&CurExGroups, (void *)eg);
  1001.             }
  1002.             zzLOOP(zztasp2);
  1003.         }
  1004.         zzEXIT(zztasp2);
  1005.         }
  1006.     }
  1007.     CurAltNum++;  
  1008.     {
  1009.         zzBLOCK(zztasp2);
  1010.         zzMake0;
  1011.         {
  1012.         while ( (LA(1)==106) ) {
  1013.             zzmatch(106);
  1014.             inAlt=1;  
  1015.  zzCONSUME;
  1016.  
  1017.             alt( toksrefd,rulesrefd );
  1018.             g = Or(g, zzaArg(zztasp2,2));  
  1019.             
  1020.             ((Junction *)g.left)->blockid = CurBlockID;
  1021.             {
  1022.                 zzBLOCK(zztasp3);
  1023.                 zzMake0;
  1024.                 {
  1025.                 while ( (LA(1)==119) ) {
  1026.                      eg  = exception_group();
  1027.  
  1028.                     
  1029.                     if ( eg!=NULL ) {
  1030.                         eg->altID = makeAltID(CurBlockID,CurAltNum);
  1031.                         CurAltStart->exception_label = eg->altID;
  1032.                         list_add(&CurExGroups, (void *)eg);
  1033.                     }
  1034.                     zzLOOP(zztasp3);
  1035.                 }
  1036.                 zzEXIT(zztasp3);
  1037.                 }
  1038.             }
  1039.             CurAltNum++;  
  1040.             zzLOOP(zztasp2);
  1041.         }
  1042.         zzEXIT(zztasp2);
  1043.         }
  1044.     }
  1045.     zzaArg(zztasp1,0) = b;  
  1046.     attribsRefdFromAction = saveblah; inAlt = saveinalt;  
  1047.     zzEXIT(zztasp1);
  1048.     return;
  1049. fail:
  1050.     zzEXIT(zztasp1);
  1051.     CannotContinue=TRUE;  
  1052.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1053.     zzresynch(setwd2, 0x80);
  1054.     }
  1055. }
  1056.  
  1057. void
  1058. #ifdef __STDC__
  1059. alt( set *toksrefd, set *rulesrefd )
  1060. #else
  1061. alt(toksrefd,rulesrefd)
  1062.  set *toksrefd;
  1063. set *rulesrefd ;
  1064. #endif
  1065. {
  1066.     zzRULE;
  1067.     zzBLOCK(zztasp1);
  1068.     zzMake0;
  1069.     {
  1070.     int n=0,ne=0; Graph g; int e_num=0, not=0; Node *node; set elems, dif;
  1071.     int first_on_line = 1, use_def_MT_handler = 0;
  1072.     g.left=NULL; g.right=NULL;
  1073.     CurAltStart = NULL;
  1074.     elems = empty;
  1075.     inAlt = 1;
  1076.     {
  1077.         zzBLOCK(zztasp2);
  1078.         zzMake0;
  1079.         {
  1080.         if ( (LA(1)==82) ) {
  1081.             zzmatch(82);
  1082.             use_def_MT_handler = 1;  
  1083.  zzCONSUME;
  1084.  
  1085.         }
  1086.         zzEXIT(zztasp2);
  1087.         }
  1088.     }
  1089.     {
  1090.         zzBLOCK(zztasp2);
  1091.         zzMake0;
  1092.         {
  1093.         int tok;  
  1094.         while ( (setwd3[LA(1)]&0x1) ) {
  1095.             {
  1096.                 zzBLOCK(zztasp3);
  1097.                 zzMake0;
  1098.                 {
  1099.                 not=0;  
  1100.                 if ( (LA(1)==107) ) {
  1101.                     zzmatch(107);
  1102.                     not=1;  
  1103.  zzCONSUME;
  1104.  
  1105.                 }
  1106.                 zzEXIT(zztasp3);
  1107.                 }
  1108.             }
  1109.              node  = element( not, first_on_line, use_def_MT_handler );
  1110.  
  1111.             if ( node!=NULL && node->ntype!=nAction ) first_on_line = 0;  
  1112.             
  1113.             if ( zzaArg(zztasp2,2 ).left!=NULL ) {
  1114.                 g = Cat(g, zzaArg(zztasp2,2));
  1115.                 n++;
  1116.                 if ( node!=NULL ) {
  1117.                     if ( node->ntype!=nAction ) e_num++;
  1118.                     /* record record number of all rule and token refs */
  1119.                     if ( node->ntype==nToken ) {
  1120.                         TokNode *tk = (TokNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1;
  1121.                         tk->elnum = e_num;
  1122.                         set_orel(e_num, &elems);
  1123.                     }
  1124.                     else if ( node->ntype==nRuleRef ) {
  1125.                         RuleRefNode *rn = (RuleRefNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1;
  1126.                         rn->elnum = e_num;
  1127.                         set_orel(e_num,  rulesrefd);
  1128.                     }
  1129.                 }
  1130.             }
  1131.             zzLOOP(zztasp2);
  1132.         }
  1133.         zzEXIT(zztasp2);
  1134.         }
  1135.     }
  1136.     if ( n == 0 ) g = emptyAlt();
  1137.     zzaArg(zztasp1,0) = g;
  1138.     /* We want to reduce number of LT(i) calls and the number of
  1139.     * local attribute variables in C++ mode (for moment, later we'll
  1140.     * do for C also).  However, if trees are being built, they
  1141.     * require most of the attrib variables to create the tree nodes
  1142.     * with; therefore, we gen a token ptr for each token ref in C++
  1143.     */
  1144.     if ( GenCC && !GenAST )
  1145.     set_orin( toksrefd, set_and(elems, attribsRefdFromAction));
  1146.     else set_orin( toksrefd, elems);
  1147.     if ( GenCC ) {
  1148.     dif = set_dif(attribsRefdFromAction, elems);
  1149.     if ( set_deg(dif)>0 )
  1150.     err("one or more $i in action(s) refer to non-token elements");
  1151.     set_free(dif);
  1152. }
  1153. set_free(elems);
  1154. set_free(attribsRefdFromAction);
  1155. inAlt = 0;
  1156.     zzEXIT(zztasp1);
  1157.     return;
  1158. fail:
  1159.     zzEXIT(zztasp1);
  1160.     CannotContinue=TRUE;  
  1161.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1162.     zzresynch(setwd3, 0x2);
  1163.     }
  1164. }
  1165.  
  1166.  LabelEntry * 
  1167. #ifdef __STDC__
  1168. element_label(void)
  1169. #else
  1170. element_label()
  1171. #endif
  1172. {
  1173.      LabelEntry *      _retv;
  1174.     zzRULE;
  1175.     zzBLOCK(zztasp1);
  1176.     zzMake0;
  1177.     {
  1178.     TermEntry *t=NULL; LabelEntry *l=NULL; RuleEntry *r=NULL; char *lab;  
  1179.     zzmatch(LABEL);
  1180.     lab = mystrdup(LATEXT(1));  
  1181.  zzCONSUME;
  1182.  
  1183.     
  1184.     UsedNewStyleLabel = 1;
  1185.     if ( UsedOldStyleAttrib ) err("cannot mix with new-style labels with old-style $i");
  1186.     t = (TermEntry *) hash_get(Tname, lab);
  1187.     if ( t==NULL ) t = (TermEntry *) hash_get(Texpr, lab);
  1188.     if ( t==NULL ) r = (RuleEntry *) hash_get(Rname, lab);
  1189.     if ( t!=NULL ) {
  1190.         err(eMsg1("label definition clashes with token/tokclass definition: '%s'", lab));
  1191.         _retv = NULL;
  1192.     }
  1193.     else if ( r!=NULL ) {
  1194.         err(eMsg1("label definition clashes with rule definition: '%s'", lab));
  1195.         _retv = NULL;
  1196.     }
  1197.     else {
  1198.         /* we don't clash with anybody else */
  1199.         l = (LabelEntry *) hash_get(Elabel, lab);
  1200.         if ( l==NULL ) {    /* ok to add new element label */
  1201.         l = (LabelEntry *)hash_add(Elabel,
  1202.         lab,
  1203.         (Entry *)newLabelEntry(lab));
  1204.         /* add to list of element labels for this rule */
  1205.         list_add(&CurElementLabels, (void *)lab);
  1206.         _retv = l;
  1207.     }
  1208.     else {
  1209.     err(eMsg1("label definitions must be unique per rule: '%s'", lab));
  1210.     _retv = NULL;
  1211. }
  1212. }
  1213.     zzmatch(97); zzCONSUME;
  1214.     zzEXIT(zztasp1);
  1215.     return _retv;
  1216. fail:
  1217.     zzEXIT(zztasp1);
  1218.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1219.     zzresynch(setwd3, 0x4);
  1220.     return _retv;
  1221.     }
  1222. }
  1223.  
  1224.  Node * 
  1225. #ifdef __STDC__
  1226. element( int not, int first_on_line, int use_def_MT_handler )
  1227. #else
  1228. element(not,first_on_line,use_def_MT_handler)
  1229.  int not;
  1230. int first_on_line;
  1231. int use_def_MT_handler ;
  1232. #endif
  1233. {
  1234.      Node *      _retv;
  1235.     zzRULE;
  1236.     zzBLOCK(zztasp1);
  1237.     zzMake0;
  1238.     {
  1239.     
  1240.     int local_use_def_MT_handler=0;
  1241.     ActionNode *act;
  1242.     RuleRefNode *rr;
  1243.     set toksrefd, rulesrefd;
  1244.     TermEntry *term;
  1245.     TokNode *p=NULL; RuleRefNode *q; int approx=0;
  1246.     LabelEntry *label=NULL;
  1247.     _retv = NULL;
  1248.     if ( (setwd3[LA(1)]&0x8) ) {
  1249.         {
  1250.             zzBLOCK(zztasp2);
  1251.             zzMake0;
  1252.             {
  1253.             if ( (LA(1)==LABEL) ) {
  1254.                  label  = element_label();
  1255.  
  1256.             }
  1257.             zzEXIT(zztasp2);
  1258.             }
  1259.         }
  1260.         {
  1261.             zzBLOCK(zztasp2);
  1262.             zzMake0;
  1263.             {
  1264.             if ( (LA(1)==TokenTerm) ) {
  1265.                 zzmatch(TokenTerm);
  1266.                 
  1267.                 term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1268.                 if ( term==NULL && UserDefdTokens ) {
  1269.                     err("implicit token definition not allowed with #tokdefs");
  1270.                     zzaRet.left = zzaRet.right = NULL;
  1271.                 }
  1272.                 else {
  1273.                     zzaRet = buildToken(LATEXT(1));
  1274.                     p=((TokNode *)((Junction *)zzaRet.left)->p1);
  1275.                     term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1276.                     require( term!= NULL, "hash table mechanism is broken");
  1277.                     p->tclass = term->tclass;
  1278.                     p->complement =  not;
  1279.                     if ( label!=NULL ) {
  1280.                         p->el_label = label->str;
  1281.                         label->elem = (Node *)p;
  1282.                     }
  1283.                 }
  1284.  zzCONSUME;
  1285.  
  1286.                 {
  1287.                     zzBLOCK(zztasp3);
  1288.                     zzMake0;
  1289.                     {
  1290.                     if ( (LA(1)==108) ) {
  1291.                         zzmatch(108); zzCONSUME;
  1292.                         {
  1293.                             zzBLOCK(zztasp4);
  1294.                             zzMake0;
  1295.                             {
  1296.                             if ( (LA(1)==QuotedTerm) ) {
  1297.                                 zzmatch(QuotedTerm);
  1298.                                 if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1299.  zzCONSUME;
  1300.  
  1301.                             }
  1302.                             else {
  1303.                                 if ( (LA(1)==TokenTerm) ) {
  1304.                                     zzmatch(TokenTerm);
  1305.                                     if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1306.  zzCONSUME;
  1307.  
  1308.                                 }
  1309.                                 else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1310.                             }
  1311.                             zzEXIT(zztasp4);
  1312.                             }
  1313.                         }
  1314.                     }
  1315.                     zzEXIT(zztasp3);
  1316.                     }
  1317.                 }
  1318.                 
  1319.                 if ( p!=NULL && (p->upper_range!=0 || p->tclass ||  not) )
  1320.                 list_add(&MetaTokenNodes, (void *)p);
  1321.                 {
  1322.                     zzBLOCK(zztasp3);
  1323.                     zzMake0;
  1324.                     {
  1325.                     if ( (LA(1)==109) ) {
  1326.                         zzmatch(109);
  1327.                         if ( p!=NULL ) p->astnode=ASTroot;  
  1328.  zzCONSUME;
  1329.  
  1330.                     }
  1331.                     else {
  1332.                         if ( (setwd3[LA(1)]&0x10) ) {
  1333.                             if ( p!=NULL ) p->astnode=ASTchild;  
  1334.                         }
  1335.                         else {
  1336.                             if ( (LA(1)==94) ) {
  1337.                                 zzmatch(94);
  1338.                                 if ( p!=NULL ) p->astnode=ASTexclude;  
  1339.  zzCONSUME;
  1340.  
  1341.                             }
  1342.                             else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1343.                         }
  1344.                     }
  1345.                     zzEXIT(zztasp3);
  1346.                     }
  1347.                 }
  1348.                 {
  1349.                     zzBLOCK(zztasp3);
  1350.                     zzMake0;
  1351.                     {
  1352.                     if ( (LA(1)==82) ) {
  1353.                         zzmatch(82);
  1354.                         local_use_def_MT_handler = 1;  
  1355.  zzCONSUME;
  1356.  
  1357.                     }
  1358.                     zzEXIT(zztasp3);
  1359.                     }
  1360.                 }
  1361.                 
  1362.                 if ( p!=NULL &&  first_on_line ) {
  1363.                     CurAltStart = (Junction *)zzaRet.left;
  1364.                     p->altstart = CurAltStart;
  1365.                 }
  1366.                 if ( p!=NULL )
  1367.                 p->use_def_MT_handler =  use_def_MT_handler || local_use_def_MT_handler;
  1368.                 _retv = (Node *)p;
  1369.             }
  1370.             else {
  1371.                 if ( (LA(1)==QuotedTerm) ) {
  1372.                     zzmatch(QuotedTerm);
  1373.                     
  1374.                     term = (TermEntry *) hash_get(Texpr, LATEXT(1));
  1375.                     if ( term==NULL && UserDefdTokens ) {
  1376.                         err("implicit token definition not allowed with #tokdefs");
  1377.                         zzaRet.left = zzaRet.right = NULL;
  1378.                     }
  1379.                     else {
  1380.                         zzaRet = buildToken(LATEXT(1)); p=((TokNode *)((Junction *)zzaRet.left)->p1);
  1381.                         p->complement =  not;
  1382.                         if ( label!=NULL ) {
  1383.                             p->el_label = label->str;
  1384.                             label->elem = (Node *)p;
  1385.                         }
  1386.                     }
  1387.  zzCONSUME;
  1388.  
  1389.                     {
  1390.                         zzBLOCK(zztasp3);
  1391.                         zzMake0;
  1392.                         {
  1393.                         if ( (LA(1)==108) ) {
  1394.                             zzmatch(108); zzCONSUME;
  1395.                             {
  1396.                                 zzBLOCK(zztasp4);
  1397.                                 zzMake0;
  1398.                                 {
  1399.                                 if ( (LA(1)==QuotedTerm) ) {
  1400.                                     zzmatch(QuotedTerm);
  1401.                                     if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1402.  zzCONSUME;
  1403.  
  1404.                                 }
  1405.                                 else {
  1406.                                     if ( (LA(1)==TokenTerm) ) {
  1407.                                         zzmatch(TokenTerm);
  1408.                                         if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1409.  zzCONSUME;
  1410.  
  1411.                                     }
  1412.                                     else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1413.                                 }
  1414.                                 zzEXIT(zztasp4);
  1415.                                 }
  1416.                             }
  1417.                         }
  1418.                         zzEXIT(zztasp3);
  1419.                         }
  1420.                     }
  1421.                     {
  1422.                         zzBLOCK(zztasp3);
  1423.                         zzMake0;
  1424.                         {
  1425.                         if ( (LA(1)==109) ) {
  1426.                             zzmatch(109);
  1427.                             if ( p!=NULL ) p->astnode=ASTroot;  
  1428.  zzCONSUME;
  1429.  
  1430.                         }
  1431.                         else {
  1432.                             if ( (setwd3[LA(1)]&0x20) ) {
  1433.                                 if ( p!=NULL ) p->astnode=ASTchild;  
  1434.                             }
  1435.                             else {
  1436.                                 if ( (LA(1)==94) ) {
  1437.                                     zzmatch(94);
  1438.                                     if ( p!=NULL ) p->astnode=ASTexclude;  
  1439.  zzCONSUME;
  1440.  
  1441.                                 }
  1442.                                 else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1443.                             }
  1444.                         }
  1445.                         zzEXIT(zztasp3);
  1446.                         }
  1447.                     }
  1448.                     {
  1449.                         zzBLOCK(zztasp3);
  1450.                         zzMake0;
  1451.                         {
  1452.                         if ( (LA(1)==82) ) {
  1453.                             zzmatch(82);
  1454.                             local_use_def_MT_handler = 1;  
  1455.  zzCONSUME;
  1456.  
  1457.                         }
  1458.                         zzEXIT(zztasp3);
  1459.                         }
  1460.                     }
  1461.                     
  1462.                     if ( p!=NULL && (p->upper_range!=0 || p->tclass ||  not) )
  1463.                     list_add(&MetaTokenNodes, (void *)p);
  1464.                     
  1465.                     if (  first_on_line ) {
  1466.                         CurAltStart = (Junction *)zzaRet.left;
  1467.                         p->altstart = CurAltStart;
  1468.                     }
  1469.                     if ( p!=NULL )
  1470.                     p->use_def_MT_handler =  use_def_MT_handler || local_use_def_MT_handler;
  1471.                     _retv = (Node *)p;
  1472.                 }
  1473.                 else {
  1474.                     if ( (LA(1)==WildCard) ) {
  1475.                         if (  not ) warn("~ WILDCARD is an undefined operation (implies 'nothing')");  
  1476.                         zzmatch(WildCard);
  1477.                         zzaRet = buildWildCard(LATEXT(1)); p=((TokNode *)((Junction *)zzaRet.left)->p1);  
  1478.  zzCONSUME;
  1479.  
  1480.                         {
  1481.                             zzBLOCK(zztasp3);
  1482.                             zzMake0;
  1483.                             {
  1484.                             if ( (LA(1)==109) ) {
  1485.                                 zzmatch(109);
  1486.                                 p->astnode=ASTroot;  
  1487.  zzCONSUME;
  1488.  
  1489.                             }
  1490.                             else {
  1491.                                 if ( (setwd3[LA(1)]&0x40) ) {
  1492.                                     p->astnode=ASTchild;  
  1493.                                 }
  1494.                                 else {
  1495.                                     if ( (LA(1)==94) ) {
  1496.                                         zzmatch(94);
  1497.                                         p->astnode=ASTexclude;  
  1498.  zzCONSUME;
  1499.  
  1500.                                     }
  1501.                                     else {zzFAIL(1,zzerr10,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1502.                                 }
  1503.                             }
  1504.                             zzEXIT(zztasp3);
  1505.                             }
  1506.                         }
  1507.                         list_add(&MetaTokenNodes, (void *)p);  
  1508.                         
  1509.                         if (  first_on_line ) {
  1510.                             CurAltStart = (Junction *)zzaRet.left;
  1511.                             p->altstart = CurAltStart;
  1512.                             if ( label!=NULL ) {
  1513.                                 p->el_label = label->str;
  1514.                                 label->elem = (Node *)p;
  1515.                             }
  1516.                         }
  1517.                         _retv = (Node *)p;
  1518.                     }
  1519.                     else {
  1520.                         if ( (LA(1)==NonTerminal) ) {
  1521.                             if (  not ) warn("~ NONTERMINAL is an undefined operation");  
  1522.                             zzmatch(NonTerminal);
  1523.                             zzaRet = buildRuleRef(LATEXT(1));  
  1524.  zzCONSUME;
  1525.  
  1526.                             {
  1527.                                 zzBLOCK(zztasp3);
  1528.                                 zzMake0;
  1529.                                 {
  1530.                                 if ( (LA(1)==94) ) {
  1531.                                     zzmatch(94);
  1532.                                     q = (RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  1533.                                     q->astnode=ASTexclude;  
  1534.  zzCONSUME;
  1535.  
  1536.                                 }
  1537.                                 zzEXIT(zztasp3);
  1538.                                 }
  1539.                             }
  1540.                             {
  1541.                                 zzBLOCK(zztasp3);
  1542.                                 zzMake0;
  1543.                                 {
  1544.                                 if ( (setwd3[LA(1)]&0x80) ) {
  1545.                                     {
  1546.                                         zzBLOCK(zztasp4);
  1547.                                         zzMake0;
  1548.                                         {
  1549.                                         if ( (LA(1)==95) ) {
  1550.                                             zzmatch(95); zzCONSUME;
  1551.                                         }
  1552.                                         zzEXIT(zztasp4);
  1553.                                         }
  1554.                                     }
  1555.                                     zzmatch(PassAction);
  1556.                                     addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  1557.  zzCONSUME;
  1558.  
  1559.                                 }
  1560.                                 zzEXIT(zztasp3);
  1561.                                 }
  1562.                             }
  1563.                             rr=(RuleRefNode *) ((Junction *)zzaRet.left)->p1;  
  1564.                             {
  1565.                                 zzBLOCK(zztasp3);
  1566.                                 zzMake0;
  1567.                                 {
  1568.                                 char *a;  
  1569.                                 if ( (LA(1)==96) ) {
  1570.                                     zzmatch(96); zzCONSUME;
  1571.                                     zzmatch(PassAction);
  1572.                                     
  1573.                                     a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1574.                                     require(a!=NULL, "rule element: cannot allocate assignment");
  1575.                                     strcpy(a, LATEXT(1));
  1576.                                     rr->assign = a;
  1577.  zzCONSUME;
  1578.  
  1579.                                 }
  1580.                                 zzEXIT(zztasp3);
  1581.                                 }
  1582.                             }
  1583.                             
  1584.                             if ( label!=NULL ) {
  1585.                                 rr->el_label = label->str;
  1586.                                 label->elem = (Node *)rr;
  1587.                             }
  1588.                             if (  first_on_line ) {
  1589.                                 CurAltStart = (Junction *)zzaRet.left;
  1590.                                 ((RuleRefNode *)((Junction *)zzaRet.left)->p1)->altstart = CurAltStart;
  1591.                             }
  1592.                             _retv = (Node *)rr;
  1593.                         }
  1594.                         else {zzFAIL(1,zzerr11,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1595.                     }
  1596.                 }
  1597.             }
  1598.             zzEXIT(zztasp2);
  1599.             }
  1600.         }
  1601.     }
  1602.     else {
  1603.         if ( (LA(1)==Action) ) {
  1604.             if (  not )    warn("~ ACTION is an undefined operation");  
  1605.             zzmatch(Action);
  1606.             zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 0);  
  1607.  zzCONSUME;
  1608.  
  1609.             if (  first_on_line ) CurAltStart = (Junction *)zzaArg(zztasp1,0 ).left;  
  1610.             _retv = (Node *) ((Junction *)zzaArg(zztasp1,0 ).left)->p1;  
  1611.         }
  1612.         else {
  1613.             if ( (LA(1)==Pred) ) {
  1614.                 if (  not )    warn("~ SEMANTIC-PREDICATE is an undefined operation");  
  1615.                 zzmatch(Pred);
  1616.                 zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 1);  
  1617.  zzCONSUME;
  1618.  
  1619.                 act = (ActionNode *) ((Junction *)zzaArg(zztasp1,0 ).left)->p1;  
  1620.                 {
  1621.                     zzBLOCK(zztasp2);
  1622.                     zzMake0;
  1623.                     {
  1624.                     char *a;  
  1625.                     if ( (LA(1)==PassAction) ) {
  1626.                         zzmatch(PassAction);
  1627.                         
  1628.                         a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1629.                         require(a!=NULL, "rule element: cannot allocate predicate fail action");
  1630.                         strcpy(a, LATEXT(1));
  1631.                         act->pred_fail = a;
  1632.  zzCONSUME;
  1633.  
  1634.                     }
  1635.                     zzEXIT(zztasp2);
  1636.                     }
  1637.                 }
  1638.                 if (  first_on_line ) CurAltStart = (Junction *)zzaArg(zztasp1,0 ).left;  
  1639.                 _retv = (Node *)act;  
  1640.             }
  1641.             else {
  1642.                 if ( (setwd4[LA(1)]&0x1) ) {
  1643.                     if (  not )    warn("~ BLOCK is an undefined operation");  
  1644.                     BlkLevel++;  
  1645.                     {
  1646.                         zzBLOCK(zztasp2);
  1647.                         zzMake0;
  1648.                         {
  1649.                         if ( (LA(1)==110) ) {
  1650.                             zzmatch(110); zzCONSUME;
  1651.                             {
  1652.                                 zzBLOCK(zztasp3);
  1653.                                 zzMake0;
  1654.                                 {
  1655.                                 if ( (LA(1)==111) ) {
  1656.                                     zzmatch(111);
  1657.                                     approx=LL_k;  
  1658.  zzCONSUME;
  1659.  
  1660.                                 }
  1661.                                 else {
  1662.                                     if ( (LA(1)==112) ) {
  1663.                                         zzmatch(112);
  1664.                                         approx = 1;  
  1665.  zzCONSUME;
  1666.  
  1667.                                     }
  1668.                                     else {
  1669.                                         if ( (LA(1)==113) ) {
  1670.                                             zzmatch(113);
  1671.                                             approx = 2;  
  1672.  zzCONSUME;
  1673.  
  1674.                                         }
  1675.                                         else {zzFAIL(1,zzerr12,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1676.                                     }
  1677.                                 }
  1678.                                 zzEXIT(zztasp3);
  1679.                                 }
  1680.                             }
  1681.                         }
  1682.                         zzEXIT(zztasp2);
  1683.                         }
  1684.                     }
  1685.                     {
  1686.                         zzBLOCK(zztasp2);
  1687.                         zzMake0;
  1688.                         {
  1689.                         if ( (LA(1)==114) ) {
  1690.                             zzmatch(114); zzCONSUME;
  1691.                             block( &toksrefd,&rulesrefd );
  1692.                             zzaRet = zzaArg(zztasp2,2); --BlkLevel;  
  1693.                             zzmatch(115); zzCONSUME;
  1694.                             {
  1695.                                 zzBLOCK(zztasp3);
  1696.                                 zzMake0;
  1697.                                 {
  1698.                                 if ( (LA(1)==116) ) {
  1699.                                     zzmatch(116);
  1700.                                     zzaRet = makeLoop(zzaRet,approx);  
  1701.  zzCONSUME;
  1702.  
  1703.                                 }
  1704.                                 else {
  1705.                                     if ( (LA(1)==117) ) {
  1706.                                         zzmatch(117);
  1707.                                         zzaRet = makePlus(zzaRet,approx);  
  1708.  zzCONSUME;
  1709.  
  1710.                                     }
  1711.                                     else {
  1712.                                         if ( (LA(1)==118) ) {
  1713.                                             zzmatch(118);
  1714.                                             zzaRet = makeBlk(zzaRet,approx);
  1715.                                             FoundGuessBlk = 1;
  1716.                                             ((Junction *) ((Junction *)zzaRet.left)->p1)->guess=1;
  1717.                                             if ( ! first_on_line ) {
  1718.                                                 err("(...)? predicate must be first element of production");
  1719.                                             }
  1720.  zzCONSUME;
  1721.  
  1722.                                         }
  1723.                                         else {
  1724.                                             if ( (setwd4[LA(1)]&0x2) ) {
  1725.                                                 zzaRet = makeBlk(zzaRet,approx);  
  1726.                                             }
  1727.                                             else {zzFAIL(1,zzerr13,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1728.                                         }
  1729.                                     }
  1730.                                 }
  1731.                                 zzEXIT(zztasp3);
  1732.                                 }
  1733.                             }
  1734.                             
  1735.                             ((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
  1736.                             ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
  1737.                             ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
  1738.                             if (  first_on_line ) 
  1739.                             CurAltStart = (Junction *)((Junction *)((Junction *)zzaRet.left)->p1);
  1740.                             _retv = (Node *) ((Junction *)zzaRet.left)->p1;  
  1741.                         }
  1742.                         else {
  1743.                             if ( (LA(1)==93) ) {
  1744.                                 zzmatch(93); zzCONSUME;
  1745.                                 block( &toksrefd,&rulesrefd );
  1746.                                 zzaRet = makeOpt(zzaArg(zztasp2,2),approx); --BlkLevel;  
  1747.                                 zzmatch(89);
  1748.                                 
  1749.                                 ((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
  1750.                                 ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
  1751.                                 ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
  1752.  zzCONSUME;
  1753.  
  1754.                                 if (  first_on_line )
  1755.                                 CurAltStart = (Junction *) ((Junction *)((Junction *)zzaRet.left)->p1);
  1756.                                 _retv = (Node *) ((Junction *)zzaRet.left)->p1;  
  1757.                             }
  1758.                             else {zzFAIL(1,zzerr14,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1759.                         }
  1760.                         zzEXIT(zztasp2);
  1761.                         }
  1762.                     }
  1763.                 }
  1764.                 else {
  1765.                     if ( (LA(1)==116) ) {
  1766.                         zzmatch(116);
  1767.                         warn("don't you want a ')' with that '*'?"); CannotContinue=TRUE;  
  1768.  zzCONSUME;
  1769.  
  1770.                     }
  1771.                     else {
  1772.                         if ( (LA(1)==117) ) {
  1773.                             zzmatch(117);
  1774.                             warn("don't you want a ')' with that '+'?"); CannotContinue=TRUE;  
  1775.  zzCONSUME;
  1776.  
  1777.                         }
  1778.                         else {
  1779.                             if ( (LA(1)==96) ) {
  1780.                                 zzmatch(96);
  1781.                                 warn("'>' can only appear after a nonterminal"); CannotContinue=TRUE;  
  1782.  zzCONSUME;
  1783.  
  1784.                             }
  1785.                             else {
  1786.                                 if ( (LA(1)==PassAction) ) {
  1787.                                     zzmatch(PassAction);
  1788.                                     warn("[...] out of context 'rule > [...]'");
  1789.                                     CannotContinue=TRUE;  
  1790.  zzCONSUME;
  1791.  
  1792.                                 }
  1793.                                 else {zzFAIL(1,zzerr15,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1794.                             }
  1795.                         }
  1796.                     }
  1797.                 }
  1798.             }
  1799.         }
  1800.     }
  1801.     zzEXIT(zztasp1);
  1802.     return _retv;
  1803. fail:
  1804.     zzEXIT(zztasp1);
  1805.     CannotContinue=TRUE;  
  1806.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1807.     zzresynch(setwd4, 0x4);
  1808.     return _retv;
  1809.     }
  1810. }
  1811.  
  1812. void
  1813. #ifdef __STDC__
  1814. default_exception_handler(void)
  1815. #else
  1816. default_exception_handler()
  1817. #endif
  1818. {
  1819.     zzRULE;
  1820.     zzBLOCK(zztasp1);
  1821.     zzMake0;
  1822.     {
  1823.      DefaultExGroup  = exception_group();
  1824.  
  1825.     zzEXIT(zztasp1);
  1826.     return;
  1827. fail:
  1828.     zzEXIT(zztasp1);
  1829.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1830.     zzresynch(setwd4, 0x8);
  1831.     }
  1832. }
  1833.  
  1834.  ExceptionGroup * 
  1835. #ifdef __STDC__
  1836. exception_group(void)
  1837. #else
  1838. exception_group()
  1839. #endif
  1840. {
  1841.      ExceptionGroup *      _retv;
  1842.     zzRULE;
  1843.     zzBLOCK(zztasp1);
  1844.     zzMake0;
  1845.     {
  1846.     ExceptionHandler *h; LabelEntry *label=NULL; FoundException = 1;  
  1847.     zzmatch(119);
  1848.     _retv = (ExceptionGroup *)calloc(1, sizeof(ExceptionGroup));  
  1849.  zzCONSUME;
  1850.  
  1851.     {
  1852.         zzBLOCK(zztasp2);
  1853.         zzMake0;
  1854.         {
  1855.         char *p;  
  1856.         if ( (LA(1)==PassAction) ) {
  1857.             zzmatch(PassAction);
  1858.             
  1859.             p = LATEXT(1)+1;
  1860.             p[strlen(p)-1] = '\0';        /* kill trailing space */
  1861.             label = (LabelEntry *) hash_get(Elabel, LATEXT(1)+1);
  1862.             if ( label==NULL )
  1863.             {
  1864.                 err(eMsg1("unknown label in exception handler: '%s'", LATEXT(1)+1));
  1865.             }
  1866.  zzCONSUME;
  1867.  
  1868.         }
  1869.         zzEXIT(zztasp2);
  1870.         }
  1871.     }
  1872.     {
  1873.         zzBLOCK(zztasp2);
  1874.         zzMake0;
  1875.         {
  1876.         while ( (LA(1)==121) ) {
  1877.              h  = exception_handler();
  1878.  
  1879.             list_add(&(_retv->handlers), (void *)h);  
  1880.             zzLOOP(zztasp2);
  1881.         }
  1882.         zzEXIT(zztasp2);
  1883.         }
  1884.     }
  1885.     {
  1886.         zzBLOCK(zztasp2);
  1887.         zzMake0;
  1888.         {
  1889.         if ( (LA(1)==120) ) {
  1890.             zzmatch(120); zzCONSUME;
  1891.             zzmatch(97); zzCONSUME;
  1892.             zzmatch(Action);
  1893.             {
  1894.                 ExceptionHandler *eh = (ExceptionHandler *)
  1895.                 calloc(1, sizeof(ExceptionHandler));
  1896.                 char *a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1897.                 require(eh!=NULL, "exception: cannot allocate handler");
  1898.                 require(a!=NULL, "exception: cannot allocate action");
  1899.                 strcpy(a, LATEXT(1));
  1900.                 eh->action = a;
  1901.                 eh->signalname = (char *) calloc(strlen("default")+1, sizeof(char));
  1902.                 require(eh->signalname!=NULL, "exception: cannot allocate sig name");
  1903.                 strcpy(eh->signalname, "default");
  1904.                 list_add(&(_retv->handlers), (void *)eh);
  1905.             }  
  1906.  zzCONSUME;
  1907.  
  1908.         }
  1909.         zzEXIT(zztasp2);
  1910.         }
  1911.     }
  1912.     
  1913.     if ( label!=NULL ) {
  1914.         /* Record ex group in sym tab for this label */
  1915.         if ( label->ex_group!=NULL ) {
  1916.             err(eMsg1("duplicate exception handler for label '%s'",label->str));
  1917.         }
  1918.         else {
  1919.             label->ex_group = _retv;
  1920.             /* Label the exception group itself */
  1921.             _retv->label = label->str;
  1922.             /* Make the labelled element pt to the exception also */
  1923.             switch ( label->elem->ntype ) {
  1924.                 case nRuleRef :
  1925.                 {
  1926.                     RuleRefNode *r = (RuleRefNode *)label->elem;
  1927.                     r->ex_group = _retv;
  1928.                     break;
  1929.                 }
  1930.                 case nToken :
  1931.                 {
  1932.                     TokNode *t = (TokNode *)label->elem;
  1933.                     t->ex_group = _retv;
  1934.                     break;
  1935.                 }
  1936.             }
  1937.         }
  1938.         /* You may want to remove this exc from the rule list
  1939.         * and handle at the labeled element site.
  1940.         */
  1941.         _retv = NULL;
  1942.     }
  1943.     zzEXIT(zztasp1);
  1944.     return _retv;
  1945. fail:
  1946.     zzEXIT(zztasp1);
  1947.     CannotContinue=TRUE;  
  1948.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1949.     zzresynch(setwd4, 0x10);
  1950.     return _retv;
  1951.     }
  1952. }
  1953.  
  1954.  ExceptionHandler * 
  1955. #ifdef __STDC__
  1956. exception_handler(void)
  1957. #else
  1958. exception_handler()
  1959. #endif
  1960. {
  1961.      ExceptionHandler *      _retv;
  1962.     zzRULE;
  1963.     zzBLOCK(zztasp1);
  1964.     zzMake0;
  1965.     {
  1966.     char *a;  
  1967.     zzmatch(121);
  1968.     
  1969.     _retv = (ExceptionHandler *)calloc(1, sizeof(ExceptionHandler));
  1970.     require(_retv!=NULL, "exception: cannot allocate handler");
  1971.  zzCONSUME;
  1972.  
  1973.     {
  1974.         zzBLOCK(zztasp2);
  1975.         zzMake0;
  1976.         {
  1977.         if ( (LA(1)==NonTerminal) ) {
  1978.             zzmatch(NonTerminal);
  1979.             
  1980.             _retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1981.             require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
  1982.             strcpy(_retv->signalname, LATEXT(1));
  1983.  zzCONSUME;
  1984.  
  1985.         }
  1986.         else {
  1987.             if ( (LA(1)==TokenTerm) ) {
  1988.                 zzmatch(TokenTerm);
  1989.                 
  1990.                 _retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1991.                 require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
  1992.                 strcpy(_retv->signalname, LATEXT(1));
  1993.  zzCONSUME;
  1994.  
  1995.             }
  1996.             else {zzFAIL(1,zzerr16,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1997.         }
  1998.         zzEXIT(zztasp2);
  1999.         }
  2000.     }
  2001.     zzmatch(97); zzCONSUME;
  2002.     {
  2003.         zzBLOCK(zztasp2);
  2004.         zzMake0;
  2005.         {
  2006.         _retv->action = NULL;  
  2007.         if ( (LA(1)==Action) ) {
  2008.             zzmatch(Action);
  2009.             
  2010.             _retv->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  2011.             require(_retv->action!=NULL, "exception: cannot allocate action");
  2012.             strcpy(_retv->action, LATEXT(1));
  2013.  zzCONSUME;
  2014.  
  2015.         }
  2016.         zzEXIT(zztasp2);
  2017.         }
  2018.     }
  2019.     zzEXIT(zztasp1);
  2020.     return _retv;
  2021. fail:
  2022.     zzEXIT(zztasp1);
  2023.     CannotContinue=TRUE;  
  2024.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  2025.     zzresynch(setwd4, 0x20);
  2026.     return _retv;
  2027.     }
  2028. }
  2029.  
  2030. void
  2031. #ifdef __STDC__
  2032. enum_file( char *fname )
  2033. #else
  2034. enum_file(fname)
  2035.  char *fname ;
  2036. #endif
  2037. {
  2038.     zzRULE;
  2039.     zzBLOCK(zztasp1);
  2040.     zzMake0;
  2041.     {
  2042.     if ( (setwd4[LA(1)]&0x40) ) {
  2043.         {
  2044.             zzBLOCK(zztasp2);
  2045.             zzMake0;
  2046.             {
  2047.             if ( (LA(1)==129) ) {
  2048.                 zzmatch(129); zzCONSUME;
  2049.                 zzmatch(ID); zzCONSUME;
  2050.                 {
  2051.                     zzBLOCK(zztasp3);
  2052.                     zzMake0;
  2053.                     {
  2054.                     if ( (LA(1)==135) ) {
  2055.                         zzmatch(135); zzCONSUME;
  2056.                         zzmatch(ID); zzCONSUME;
  2057.                     }
  2058.                     zzEXIT(zztasp3);
  2059.                     }
  2060.                 }
  2061.             }
  2062.             zzEXIT(zztasp2);
  2063.             }
  2064.         }
  2065.         {
  2066.             zzBLOCK(zztasp2);
  2067.             zzMake0;
  2068.             {
  2069.             if ( (LA(1)==137) ) {
  2070.                 {
  2071.                     zzBLOCK(zztasp3);
  2072.                     int zzcnt=1;
  2073.                     zzMake0;
  2074.                     {
  2075.                     do {
  2076.                         enum_def(  fname );
  2077.                         zzLOOP(zztasp3);
  2078.                     } while ( (LA(1)==137) );
  2079.                     zzEXIT(zztasp3);
  2080.                     }
  2081.                 }
  2082.             }
  2083.             else {
  2084.                 if ( (LA(1)==135) ) {
  2085.                     defines(  fname );
  2086.                 }
  2087.                 else {zzFAIL(1,zzerr17,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2088.             }
  2089.             zzEXIT(zztasp2);
  2090.             }
  2091.         }
  2092.     }
  2093.     else {
  2094.         if ( (LA(1)==Eof) ) {
  2095.         }
  2096.         else {zzFAIL(1,zzerr18,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2097.     }
  2098.     zzEXIT(zztasp1);
  2099.     return;
  2100. fail:
  2101.     zzEXIT(zztasp1);
  2102.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  2103.     zzresynch(setwd4, 0x80);
  2104.     }
  2105. }
  2106.  
  2107. void
  2108. #ifdef __STDC__
  2109. defines( char *fname )
  2110. #else
  2111. defines(fname)
  2112.  char *fname ;
  2113. #endif
  2114. {
  2115.     zzRULE;
  2116.     zzBLOCK(zztasp1);
  2117.     zzMake0;
  2118.     {
  2119.     int v,maxt= -1; char *t;  
  2120.     {
  2121.         zzBLOCK(zztasp2);
  2122.         int zzcnt=1;
  2123.         zzMake0;
  2124.         {
  2125.         do {
  2126.             zzmatch(135); zzCONSUME;
  2127.             zzmatch(ID);
  2128.             t = mystrdup(LATEXT(1));  
  2129.  zzCONSUME;
  2130.  
  2131.             zzmatch(INT);
  2132.             
  2133.             v = atoi(LATEXT(1));
  2134.             /*            fprintf(stderr, "#token %s=%d\n", t, v);*/
  2135.             TokenNum = v;
  2136.             if ( v>maxt ) maxt=v;
  2137.             if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  2138.             else {
  2139.                 warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
  2140.             }
  2141.  zzCONSUME;
  2142.  
  2143.             zzLOOP(zztasp2);
  2144.         } while ( (LA(1)==135) );
  2145.         zzEXIT(zztasp2);
  2146.         }
  2147.     }
  2148.     TokenNum = maxt + 1;  
  2149.     zzEXIT(zztasp1);
  2150.     return;
  2151. fail:
  2152.     zzEXIT(zztasp1);
  2153.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  2154.     zzresynch(setwd5, 0x1);
  2155.     }
  2156. }
  2157.  
  2158. void
  2159. #ifdef __STDC__
  2160. enum_def( char *fname )
  2161. #else
  2162. enum_def(fname)
  2163.  char *fname ;
  2164. #endif
  2165. {
  2166.     zzRULE;
  2167.     zzBLOCK(zztasp1);
  2168.     zzMake0;
  2169.     {
  2170.     int v= 0; char *t;  
  2171.     zzmatch(137); zzCONSUME;
  2172.     zzmatch(ID); zzCONSUME;
  2173.     zzmatch(138); zzCONSUME;
  2174.     zzmatch(ID);
  2175.     t = mystrdup(LATEXT(1));  
  2176.  zzCONSUME;
  2177.  
  2178.     {
  2179.         zzBLOCK(zztasp2);
  2180.         zzMake0;
  2181.         {
  2182.         if ( (LA(1)==139) ) {
  2183.             zzmatch(139); zzCONSUME;
  2184.             zzmatch(INT);
  2185.             v=atoi(LATEXT(1));  
  2186.  zzCONSUME;
  2187.  
  2188.         }
  2189.         else {
  2190.             if ( (setwd5[LA(1)]&0x2) ) {
  2191.                 v++;  
  2192.             }
  2193.             else {zzFAIL(1,zzerr19,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2194.         }
  2195.         zzEXIT(zztasp2);
  2196.         }
  2197.     }
  2198.     
  2199.     /*            fprintf(stderr, "#token %s=%d\n", t, v);*/
  2200.     TokenNum = v;
  2201.     if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  2202.     else {
  2203.         warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
  2204.     }
  2205.     {
  2206.         zzBLOCK(zztasp2);
  2207.         zzMake0;
  2208.         {
  2209.         while ( (LA(1)==140) ) {
  2210.             zzmatch(140); zzCONSUME;
  2211.             {
  2212.                 zzBLOCK(zztasp3);
  2213.                 zzMake0;
  2214.                 {
  2215.                 if ( (LA(1)==ID) ) {
  2216.                     zzmatch(ID);
  2217.                     t = mystrdup(LATEXT(1));  
  2218.  zzCONSUME;
  2219.  
  2220.                     {
  2221.                         zzBLOCK(zztasp4);
  2222.                         zzMake0;
  2223.                         {
  2224.                         if ( (LA(1)==139) ) {
  2225.                             zzmatch(139); zzCONSUME;
  2226.                             zzmatch(INT);
  2227.                             v=atoi(LATEXT(1));  
  2228.  zzCONSUME;
  2229.  
  2230.                         }
  2231.                         else {
  2232.                             if ( (setwd5[LA(1)]&0x4) ) {
  2233.                                 v++;  
  2234.                             }
  2235.                             else {zzFAIL(1,zzerr20,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  2236.                         }
  2237.                         zzEXIT(zztasp4);
  2238.                         }
  2239.                     }
  2240.                     
  2241.                     /*                    fprintf(stderr, "#token %s=%d\n", t, v);*/
  2242.                     TokenNum = v;
  2243.                     if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  2244.                     else {
  2245.                         warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
  2246.                     }
  2247.                 }
  2248.                 zzEXIT(zztasp3);
  2249.                 }
  2250.             }
  2251.             zzLOOP(zztasp2);
  2252.         }
  2253.         zzEXIT(zztasp2);
  2254.         }
  2255.     }
  2256.     zzmatch(141); zzCONSUME;
  2257.     zzmatch(142);
  2258.     TokenNum++;  
  2259.  zzCONSUME;
  2260.  
  2261.     zzEXIT(zztasp1);
  2262.     return;
  2263. fail:
  2264.     zzEXIT(zztasp1);
  2265.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  2266.     zzresynch(setwd5, 0x8);
  2267.     }
  2268. }
  2269.  
  2270. /* semantics of #token */
  2271. static void
  2272. #ifdef __STDC__
  2273. chkToken(char *t, char *e, char *a, int tnum)
  2274. #else
  2275. chkToken(t,e,a,tnum)
  2276. char *t, *e, *a;
  2277. int tnum;
  2278. #endif
  2279. {
  2280.     TermEntry *p;
  2281.     
  2282.     /* check to see that they don't try to redefine a token as a token class */
  2283.     if ( t!=NULL ) {
  2284.     p = (TermEntry *) hash_get(Tname, t);
  2285.     if ( p!=NULL && p->classname ) {
  2286.     err(eMsg1("redefinition of #tokclass '%s' to #token not allowed; ignored",t));
  2287.     if ( a!=NULL ) free((char *)a);
  2288.     return;
  2289. }
  2290. }
  2291.  
  2292.     if ( t==NULL && e==NULL ) {            /* none found */
  2293. err("#token requires at least token name or rexpr");
  2294. }
  2295. else if ( t!=NULL && e!=NULL ) {    /* both found */
  2296. if ( UserDefdTokens ) {            /* if #tokdefs, must not define new */
  2297. p = (TermEntry *) hash_get(Tname, t);
  2298. if ( p==NULL ) {
  2299. err(eMsg1("#token definition '%s' not allowed with #tokdefs; ignored",t));
  2300. return;
  2301. }
  2302. }
  2303. Tklink(t, e);
  2304. if ( a!=NULL ) {
  2305. if ( hasAction(e) ) {
  2306. err(eMsg1("redefinition of action for %s; ignored",e));
  2307. }
  2308. else setHasAction(e, a);
  2309. }
  2310. }
  2311. else if ( t!=NULL ) {                /* only one found */
  2312. if ( UserDefdTokens ) {
  2313. err(eMsg1("#token definition '%s' not allowed with #tokdefs; ignored",t));
  2314. return;
  2315. }
  2316. if ( Tnum( t ) == 0 ) addTname( t );
  2317. else {
  2318. err(eMsg1("redefinition of token %s; ignored",t));
  2319. }
  2320. if ( a!=NULL ) {
  2321. err(eMsg1("action cannot be attached to a token name (%s); ignored",t));
  2322. free((char *)a);
  2323. }
  2324. }
  2325. else if ( e!=NULL ) {
  2326. if ( Tnum( e ) == 0 ) addTexpr( e );
  2327. else {
  2328. if ( hasAction(e) ) {
  2329. err(eMsg1("redefinition of action for expr %s; ignored",e));
  2330. }
  2331. else if ( a==NULL ) {
  2332. err(eMsg1("redefinition of expr %s; ignored",e));
  2333. }
  2334. }
  2335. if ( a!=NULL ) setHasAction(e, a);
  2336. }
  2337.  
  2338.     /* if a token type number was specified, then add the token ID and 'tnum'
  2339. * pair to the ForcedTokens list.  (only applies if an id was given)
  2340. */
  2341. if ( t!=NULL && tnum>0 )
  2342. {
  2343. if ( set_el(tnum, reserved_positions) )
  2344. {
  2345. err(eMsgd("a token has already been forced to token number %d; ignored", tnum));
  2346. }
  2347. else
  2348. {
  2349. list_add(&ForcedTokens, newForcedToken(t,tnum));
  2350. set_orel(tnum, &reserved_positions);
  2351. }
  2352. }
  2353. }
  2354.  
  2355. /* ANTLR-specific syntax error message generator
  2356. * (define USER_ZZSYN when compiling so don't get 2 definitions)
  2357. */
  2358. void
  2359. #ifdef __STDC__
  2360. zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok,  
  2361. int k, char *bad_text)
  2362. #else
  2363. zzsyn(text, tok, egroup, eset, etok, k, bad_text)
  2364. char *text, *egroup, *bad_text;
  2365. int tok;
  2366. int etok;
  2367. int k;
  2368. SetWordType *eset;
  2369. #endif
  2370. {
  2371. fprintf(stderr, ErrHdr, FileStr[CurFile]!=NULL?FileStr[CurFile]:"stdin", zzline);
  2372. fprintf(stderr, " syntax error at \"%s\"", (tok==zzEOF_TOKEN)?"EOF":text);
  2373. if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
  2374. if ( k==1 ) fprintf(stderr, " missing");
  2375. else
  2376. {
  2377. fprintf(stderr, "; \"%s\" not", bad_text);
  2378. if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
  2379. }
  2380. if ( zzset_deg(eset)>0 ) zzedecode(eset);
  2381. else fprintf(stderr, " %s", zztokens[etok]);
  2382. if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
  2383. fprintf(stderr, "\n");
  2384. }
  2385.